import { Component, OnInit } from '@angular/core';
import { SharedService } from './shared.service';
import { Subject, Subscription, Observable, interval, timer, BehaviorSubject } from 'rxjs';
import { take } from 'rxjs/operators';

@Component({
  selector: 'app-father',
  templateUrl: './father.component.html',
  styleUrls: ['./father.component.less']
})
export class FatherComponent implements OnInit {
  alertMsg: string;
  subject$ = new Subject();
  subjectSubscription = new Subscription();

  constructor(private service: SharedService) { }

  ngOnInit(): void {
    const a = this.service.getMessage().subscribe(data => { this.alertMsg = data; return this.alertMsg });

    // 1.理解subject组播
    this.subjectSubscription = this.subject$.subscribe(data => console.log(data))   //subject.subscribe()  只是注册，不会去执行

    this.subject$.next(Math.random());  //执行

    this.subjectSubscription && this.subjectSubscription.unsubscribe();

    // subject是一个特殊的对象，即可以是数据生产者，也同时是消费者，通过使用Subject作为数据消费者，可以使用它们将Observables从单播转为多播，栗子如下：
    // 2.使用subject将observables从单播转换为多播
    const observable = Observable.create(observer => {
      observer.next(Math.random());
    })

    // const subject = new Subject();
    // subject.subscribe(data => console.log(data));
    // observable.subscribe(subject);


    // const source = interval(1000).pipe(take(3));
    // const observerA = {
    //   next: (data: any) => console.log(`A${data}`),
    //   error: (err: any) => console.log(`B${err}`),
    //   complete: () => console.log(`Acompelete`)
    // }
    // const observerB = {
    //   next: (data: any) => console.log(`B${data}`),
    //   error: (err: any) => console.log(`B${err}`),
    //   complete: () => console.log(`Bcompelete`)
    // }
    // source.subscribe(observerA);
    // timer(1000).subscribe(() => {
    //   source.subscribe(observerB);
    // })

    // 以上结果表明两次的订阅是完全分开来执行的，或者说是每次的订阅都建立了一个新的执行；
    // 这样的行为在大部分情境下使用，但是有些情况我们希望第二次订阅source不从头开始接收元素，而是从第一次订阅到当前处理的元素开始发送，这种处理方式称为组播；
    // const source = interval(1000).pipe(take(3));
    // const subject = new Subject();
    // const observerA = {
    //   next: (data: any) => console.log(`A${data}`),
    //   error: (err: any) => console.log(`B${err}`),
    //   complete: () => console.log(`Acompelete`)
    // }
    // const observerB = {
    //   next: (data: any) => console.log(`B${data}`),
    //   error: (err: any) => console.log(`B${err}`),
    //   complete: () => console.log(`Bcompelete`)
    // }
    // subject.subscribe(observerA);
    // subject.subscribe(observerB);
    // source.subscribe(subject);
    //Subject 同时是 Observable 又是 Observer
    //Subject 会对内部的 observers 清单列表进行组播(multicast)


    //behaviorSubject是subject的一个变种，他的特点是会存储当前值
    const subject = new Subject();
    subject.subscribe(data => console.log(data));
    subject.next();

    // behaviorSubject一旦subscribe就会执行，可以在定义时初始化
    const bsubject = new BehaviorSubject(0);
    bsubject.subscribe(data => console.log(data))
  }


}
